Углублённый Python

спринт 1
Как мы учим?
8/8
Числовые типы
2/2
Булева алгебра. Условные операторы
1/1
Условные операторы и тип Bool
Последовательности
3/3
Python «под капотом»
1/1
Последовательности: продолжение
2/2
Множества set()
1/1
Словари
1/1
Типы данных
1/1
Создание функций
1/1
Стандартная библиотека
2/2
Финальный проект спринта: программа-шагомер для фитнес-трекера
2/2
Как искать решение
4/4
спринт 2
Перед тем как начать
1/1
Введение
2/2
Настройка окружения: Python, IDE, venv
6/6
Настройка окружения: Git, pytest
7/7
Требования к коду
7/7
Основы отладки программ
3/3
спринт 3
Самое необходимое об ООП
8/8
Финальный проект спринта: модуль фитнес-трекера
5/5
Учебная среда
4/4
Спринт 1/18 → Тема 3/13: Булева алгебра. Условные операторы → Урок 1/1

Условные операторы и тип Bool

Простейшие программы работают линейно: все инструкции выполняются беспрекословно и последовательно, шаг за шагом. Но для большинства задач такой подход неприемлем: в зависимости от ситуации выполнение программы должно идти по разным сценариям, варьироваться и ветвиться. А у разработчика должен быть инструмент, который позволит ему реализовать такое ветвление в коде.
Вы уже работали с ветвлением, но в эту тему стоит погрузиться поглубже, ведь это одна из фундаментальных основ программирования.

Оператор if

Условный оператор if (англ. «если») задаёт определённое поведение программы в зависимости от заданных разработчиком условий: «если условие истинно — выполни код, следующий за условием».
Простым примером будет программа, которая получает из онлайн-кинотеатра усреднённую оценку фильма и, в зависимости от оценки, выводит то или иное сообщение.
Самый простой вариант: если оценка больше 4.7 — пусть программа выведет сообщение «Фильм крут» (оценка фильмов ведётся по пятибалльной шкале). Если оценка фильма меньше или равна 4.7 — программа деликатно промолчит.
После выполнения работы программа в любом случае должна напечатать сообщение «Проверка окончена».
На блок-схеме — последовательность действий, алгоритм для решения поставленной задачи.
В коде этот алгоритм описывается через условный оператор if
Запустите код и посмотрите что напечатает программа.
Измените оценку фильма и запустите код ещё раз.
КодPYTHON

Синтаксис условного оператора

  • Объявление ветвления: ключевое слово if и условие;
  • После условия — обязательно двоеточие. Оно говорит интерпретатору, что дальше будет тело условного оператора.
  • Тело условного оператора отбивается четырьмя пробелами от начала строки с объявлением ветвления; эти отступы обязательны, иначе интерпретатор не поймёт, где начинается и где кончается тело условного оператора.

Конструкция if...else

Если рейтинг фильма ниже определённого порога — программа ничего об этом не скажет. Стоит изменить это поведение и сообщить пользователю, что смотреть этот фильм не стоит. Лучше горькая правда, чем стыдливое умолчание.
Логика программы должна стать такой:
  • если (if) оценка фильма выше 4.7 — выводить реплику «Фильм крут»;
  • иначе (else) выводить строку «Так себе киношечка»;
  • после вывода сообщений (в любом случае) напечатать строку «Проверка окончена».
Фактически нужно обработать ситуацию, когда условие, описанное в if, не выполняется. Для этого в конструкции условного оператора предусмотрено ключевое слово else (англ. «иначе»). Код, записанный после этого ключевого слова, сработает в том случае, если условие в if ложно.
Внимание на отступы: ключевое слово else пишется на том же уровне, что и if, а код, выполняемый после else, пишется с четырьмя отступами от else:
PYTHON
rating = 4.9

if rating > 4.7:
    print('Фильм крут')
else:
    # Код выполнится, если rating <= 4.7
    # Отступы важны!
    print('Так себе киношечка')

print('Проверка окончена')
В else не указывают никаких условий: код из этого блока будет выполнен в любой ситуации, когда условие после if не выполнено.

Тернарный оператор

В Python есть выражения, служащие для упрощения кода. Например, простую условную конструкцию if...else можно записать коротко:
PYTHON
rating = 4.9

# Так вы умеете:
if rating > 4.7:
    print('Фильм крут')
else:
    print('Так себе киношечка')

# А так будет короче:
result = 'Фильм крут' if rating > 4.7 else 'Так себе киношечка'
# В отличие от обычной конструкции if...else 
# тернарный оператор не просто выполняет блок кода, 
# а возвращает значение
print(result)

print('Проверка окончена')
Синтаксис тернарного оператора:
В примере 'Фильм крут' если rating > 4.7, иначе 'Так себе киношечка'
  • если rating больше 4.7 — оператор вернёт значение 'Фильм крут';
  • если условие не выполнено — оператор вернёт строку 'Так себе киношечка'.

Конструкция if...elif...else

Программа уже может отличить крутые фильмы ото всякой ерунды. Но это довольно грубое разделение: мир не чёрно-белый, и фильмы не делятся только на «совсем плохие» и «безусловно хорошие»: есть и полутона. Значит, стоит задача определить более двух категорий фильмов: если рейтинг больше 4.7 — прекрасный фильм, если рейтинг меньше 4.7, но больше 3.5 — фильм из разряда «сойдёт», а фильмы с рейтингом ниже 3.5 зачисляем в группу «так себе киношечка».
Теперь ожидаемую логику программы можно описать так:
  • если (if)оценка фильма выше 4.7 — выводить реплику «Фильм крут»;
  • если (elif) оценка выше 3.5, но не выше 4.7 — напечатать строку «Смотреть можно»;
  • иначе (else) выводить строку «Так себе киношечка»;
  • после вывода сообщений в любом случае напечатать строку «Проверка окончена». Алгоритм выполнения программы будет такой:
Чтобы воплотить этот алгоритм в коде, придётся применить вложенные ветвления:
PYTHON
rating = 4.9

if rating > 4.7:
    print('Фильм крут')
else:
    # Вложенное ветвление
    if rating > 3.5:
        print('Смотреть можно')
    else:
        print('Так себе киношечка')

print('Проверка окончена')
Конструкция получилась запутанной, а это увеличило шансы на ошибку: дополнительные вложенности, отступы и условия усложняют код; а если условий будет больше — код станет совсем нечитаемым.
В конструкции условного оператора if есть специальный блок, в котором можно не просто обработать «все прочие варианты, противоречащие условию в if», но и задать дополнительное условие.
Для этого применяют блок elif (от англ. «иначе-если»): «если условие в if не выполняется — проверим на другое условие». Блок elif — это «синтаксический сахар» для конструкции else с вложенным if; elif делает то же самое, но код становится «плоским», без вложенностей, и за счёт этого — более читаемым и структурированным.
Flat is better than nested Плоское лучше, чем вложенное. ©The Zen of Python
  • После ключевого слова elif записывается условие,
  • после условия ставится двоеточие, точно как в if;
  • код в теле блока сработает, если условие в elif выполнится;
  • код в теле elif отбивается четырьмя отступами.
Теперь программа выглядит получше:
PYTHON
rating = 3.0

if rating > 4.7:
    print('Фильм крут')
elif rating > 3.5:
    print('Смотреть можно')
else:
    print('Так себе киношечка')
print('Проверка окончена')
В конструкцию if...elif...else может быть включено сколько угодно блоков elif — при ветвлении это позволит учесть все возможные варианты.
Программа читает код ветвления сверху вниз, и как только одно из условий сработает — программа выполнит код в теле этого условия, а в следующие блоки (elif и else) не будет даже заглядывать.
Следовательно, очень важен порядок, в котором установлены условия. Например, если в самом начале ветвления поставить проверку if rating > 3.5, то программа никогда не дойдёт до условия elif rating > 4.7
PYTHON
rating = 5

if rating > 3.5:
    print('Смотреть можно')
elif rating > 4.7:
    print('Фильм крут')
else:
    print('Так себе киношечка')
print('Проверка окончена')

# Вывод в терминал: Смотреть можно
# хотя, по логике, должно быть 'Фильм крут'

Вложенные условия

Конструкции if можно вкладывать одну в другую. Расширим код условием if rating: — такая проверка позволит убедиться, что rating не равен 0 или None.
PYTHON
rating = 4.9

if rating:
    if rating > 4.7:
        print('Фильм крут')
    else:
        if rating > 3.5:
            print('Смотреть можно')
        else:
            print('Так себе киношечка')
else:
   print('У фильма нет оценки') 

print('Проверка окончена')
В Python нет ограничений для уровней вложенности, главное — не запутаться в отступах. Но применять этот подход стоит только в случаях, когда нет других вариантов:
  • чем больше вложенность, тем больше вероятность допустить ошибку. Например, можно забыть отступ, и программа не будет работать по задуманному алгоритму;
  • код становится трудночитаемым. Программисты в крупных проектах работают совместно, и в такой ситуации становится важным качество и чистота кода. Чем код проще — тем он легче для понимания.

Операторы сравнения

Когда выполнение программы доходит до ключевого слова if — Python проверяет описанное условие, например rating > 4.7. Операторов сравнения не так уж и много:
В операторах «меньше или равно» и «больше или равно» символы указываются в порядке «как слышится — так и пишется». Обычно говорят «меньше или равно», так же и пишут: <=.

Логический тип bool

Выражения с операторами сравнения возвращают значение типа bool. Это логический тип данных, который имеет лишь два значения: True (истина) и False (ложь) .
Тип bool — это подкласс типа int, и значения True и False можно конвертировать в целые числа:
  • int(True) приведёт значение к числу 1
  • int(False) приведёт значение к числу 0

Особенности проверки истинности в логических выражениях:

Любое число, не равное 0, или непустой объект конвертируются в True:
PYTHON
rating = 1.1

if rating: # Переменная rating равна 1.1, значит условие вернет True
    print('Оценка поставлена')
else:
    print('У фильма нет оценки')

# Вывод в терминал: 'Оценка поставлена'
Число 0, пустые объекты и значение None конвертируются в False
PYTHON
rating = 0 

if rating: # Переменная rating равна 0, значит условие вернет False.
    print('Оценка поставлена')
else:
    print('У фильма нет оценки')

# Вывод в терминал: 'У фильма нет оценки'
Сравнение с None выполняется по ключевому слову is: оператор == не сработает.
PYTHON
rating = None 

if rating is None: 
    print('У фильма нет оценки')
else:
    print('Оценка поставлена')
Что будет напечатано при выполнении кода print(5 > 4)?

Логические операторы

Если у фильма нулевой рейтинг — первое условие вернёт False, и без вложенных условий if обработать такую проверку, вроде бы, невозможно:
PYTHON
rating = 0

if rating:
    if rating > 4.7:
        print('Фильм оценили и очень высоко!')
else:
    print('У фильма нет оценки')
        
print('Проверка окончена')
В коде применяется вложенность конструкций if, а этого лучше избегать. Было бы лучше записать два логических выражения в одном условии — это будет короче и нагляднее.
В Python есть возможность объединять логические выражения в одной строке: для этого есть логические операторы and и or. С их помощью можно связать логические выражения в общую систему.
Например, можно объединить два условия в одно:
PYTHON
if оценка фильма получена [и, одновременно] оценка больше 4.7:
    print('Отличный фильм, бегом за билетами!')

Оператор AND

Логический оператор and (И) возвращает True, если оба логических выражения вернут True; если хоть одно из выражений вернёт False — то оператор and вернёт False.
PYTHON
rating = 4.9

if rating and rating >= 4.7:
    # При rating = 4.9 это условие вернёт True
    print('Отличный фильм, бегом за билетами!')
else:
    # Если оценки нет или она меньше 4.7
    print('У фильма нет оценки')
        
print('Проверка окончена')
Рассмотрим историю программиста, едущего ночью на машине домой в Санкт-Петербурге. У него на пути два моста; каждый мост — это условие: если мост разведён — условие ложно и вернёт False, если мост сведён — True.
PYTHON
if мост №1 сведён AND мост №2 сведён:
    # Если выражение в if вернёт True
    Программист доберётся до дома
else:
    Программист ночует в офисе
Автомобиль доедет до цели только в том случае, если первый И второй мост будут сведены, «вернут True».

Оператор OR

Логический оператор or (англ. «или»): возвращает True, если хотя бы одно из логических выражений возвращает True.
Продолжим историю про питерского программиста: он обнаружил два альтернативных маршрута, на каждом из маршрутов — по мосту; теперь его устроит, если сведён хотя бы один из мостов: можно проехать, он доберётся до дома. Если хотя бы один мост вернёт True — всё будет True.
PYTHON
if мост №1 сведён OR мост №2 сведён:
    # Если выражение в if вернёт True
    Программист доберётся до дома
else:
    Программист ночует в офисе
PYTHON
bridge_1 = 'сведён'
bridge_2 = 'разведён'

if bridge_1 == 'сведён' or bridge_2 == 'сведён':
    print('Программист доберётся до дома')
else:
    print('Программист ночует в офисе')
Если хотя бы один мост сведён — автомобиль сможет добраться до цели.

Оператор NOT

Оператор not инвертирует булевы значения: not True вернёт False; not False вернёт True.
Наглядным примером может послужить кнопка Start-Stop в автомобиле. Нажатие на кнопку должно включить двигатель или выключить его, в зависимости от того, работает сейчас двигатель или нет.
  • двигатель заглушен: status = False;
  • двигатель включен: status = True
При каждом нажатии на кнопку надо менять статус двигателя на противоположный. Можно написать проверку условия:
PYTHON
status = True

# При каждом нажатии на кнопку запускается этот код:
if status:
    # Если status равен True - присваиваем ему значение False
    status = False
else:
    # Если status равен False - присваиваем ему значение True 
    status = True

print(status)
А можно написать то же самое гораздо короче, через not:
PYTHON
status = True

# При каждом нажатии на кнопку запускается этот код:
# Каким бы ни было значение переменной - заменяем его на противоположное
status = not status 
print(status)
Впереди вас ждут задачи, которые помогут закрепить знания, полученные в этом уроке. А чтобы закреплять их было проще — пользуйтесь шпаргалкой с краткой информацией об условных операторах и типе Bool.
Напишите программу, которая при запуске получает значения x и y, координаты точки на плоскости. Программа должна определить, в какой четверти на координатной плоскости находится точка с переданными координатами.
КодPYTHON